COMMENT ⊗   VALID 00020 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00003 00002	 MacLisp portion of the E/MacLisp Interface.
C00008 00003	 αxSLISP dsk:maclsp.dmp[1,3](elisp.ini)
C00017 00004	(lap em:get-mail subr)
C00021 00005	(entry em:mail-type subr)
C00026 00006	(entry em:wait-mail subr)
C00027 00007	(entry em:mail-sfa subr)
C00030 00008	 TYI
C00032 00009	 TYO
C00034 00010	 FORCE OUTPUT
C00037 00011	 This routine gets fresh mail to initialize the reader
C00042 00012	 This routine does a jobread into the right spot.
C00044 00013	wait-ok  
C00045 00014	(entry em:send-simple-message subr)
C00048 00015	(entry em:send-control-char subr)
C00050 00016	(entry em:init subr)
C00051 00017	send-ok
C00052 00018	(entry em:eval-protect subr)
C00053 00019	 Routines for obtaining the values of readonly variables
C00054 00020	 Storage for Mail routines
C00057 ENDMK
C⊗;
;;; MacLisp portion of the E/MacLisp Interface.
;;;
;;; An SFA/MAIL based system for communicating with
;;; an unstructured, standard text editor.
;;; Starts with -em:jobnum- figured out from E.
;;; (sfa-call <sfa> 'send-lines n)
;;; sets the number of lines that are sent at one time to n.
;;; normal is T (meaning send every line).
;;; NIL means never send.
;;; (sfa-call <sfa> 'report-send-lines) returns the value
;;; (ecalledp) defined in (HELP) tells whether E called you

(declare (mapex t)
         (setq defmacro-for-compiling ())
	 (special -em:jobnum- -em:e-commands- -em:sfa- -em:errorp- 
		  -em:filemode- grlinel)
	 (fixnum -em:jobnum-))

(setq -em:e-commands- ()
      -em:filemode- ()
      grlinel (linel t))

(setq -em:sfa- ())

(defun em:initialize ()
       (em:get-jobnum)
       (em:init)
       (em:init-send-lines)
       (em:send-simple-message 'ok -em:jobnum-)
       (setq -em:sfa- (sfa-create (function em:mail-sfa) 0 'mail-sfa))
       (setq tyi -em:sfa-)
       (setq tyo -em:sfa-)
       t)
 
(set (symeval (implode `(,(ascii 125.),(ascii 80.))))
	      '$P)

(defmacro unascii (x)
 `(car (exploden ,x)))

(defun em:ecommands (l)
       (let ((-em:e-commands- t))
	    (do ((com l (cdr com)))
		((null com)(sfa-call -em:sfa- 'force-output ()))
		(sfa-call -em:sfa- 'tyo (unascii (car com))))))

(defun em:set-send-lines (n)
 (sfa-call -em:sfa- 'send-lines n))

(defun em:get-send-lines ()
 (sfa-call -em:sfa- 'report-send-lines ()))

(defun em:force ()
 (sfa-call -em:sfa- 'force-output ()))

(defun em:terpri () (terpri -em:sfa-))

(setq read-eval-print-* 'em:terpri)

(defun em:eval-until-eof (eof) 
  (do ((form (read) (read)) (l nil)) 
      ((eq form eof)
       (do ((i (nreverse l) (cdr i))) ((null i)) 
	   (print (car i))(terpri))) 
   (setq l (cons (eval form) l))))

(defun fread n
 ((lambda (-em:filemode-)
	  (cond ((zerop n)
		 (read))
		((= n 1)
		 (read (arg 1)))
		((= n 2)
		 (read (arg 1)(arg 2)))
		(t 
		 (error '|too many args to FREAD|))))
  t))
;;; αxSLISP dsk:maclsp.dmp[1,3](elisp.ini)
;;; αnαxSLISP talks to job n(10.)
;;; α0αxSLISP types the wholine of inferior
;;; α-αxSLISP murder (i.e. negotiated suicide)
;;; α=	send arrow line or attach buffer
;;; α+nα=	send next n lines
;;; α-nα=	send previous n lines
;;; αx= <sexp>
;;; 	send comand line
;;; 
;;; Protocols: (* means not actually anticipated to be used; current
;;; implementation knows about it but does not send and/or interpret them
;;; specially)
;;; 
;;; From E to MacLisp
;;; 	Mail
;;; 	wd0:	Job# sending message
;;; 	wd1:	type of message
;;; 
;;; 2,,0:   Continuation needed
;;; 1,,0:	Short (fits in the next =30 words, ends with null byte
;;;         or falls off)
;;; 
;;; 0		no-op
;;; 1		initiating a conversation
;;; 2		ok (did the jobread)
;;; 3		SEXPs
;;; 4		explicit eof
;;; 5		control (meta) chars to follow (E macro format)
;;; 		 (or E commands (from MacLisp to E))
;;; 6		interrupt. do <esc>i <char>
;;; 7		close connection (suicide)
;;; 
;;; 	wd2:	-number of bytes,,address of buffer
;;; 		
;;; 
;;; E commands will be represented in the standard E macro manner
;;; (unless there is something better).
;;; 
;;; 
;;; Protocol is:
;;; 	E	MacLisp
;;;         ---------------
;;; 	initiate
;;; 		ok
;;; 
;;; To send a short message just a MAIL
;;; To send a long message MAIL then wait for JOBREAD acknowledge
;;; To send interrupts, just send them
;;; Acknowledgment is the short OK message
;;; 
;;; Commands needed:
;;; 	start DMP file
;;; 	send control chars
;;; 	send interrupt character (just 1 at a time)
;;; 
(lap em:get-mail subr)
(args em:get-mail (nil . 0))

	(defsym EPR #o456062)
	(defsym noutbytes #o10000)
	(defsym rdblk #o2000)
	(defsym blksize #o2000)

	(defsym lf #o12)
	(defsym cr #o15)
	(defsym noop-type 0)
	(defsym initiate-type 1)
	(defsym ok-type 2)
	(defsym sexp-type 3)
	(defsym explicit-eof-type 4)
	(defsym ecommand-type 5)
	(defsym interrupt-type 6)
	(defsym kill-type 7)
	(defsym readonlyvar-type 8.)
	(defsym high-command 8.)

	(defsym alpha 2)
	(defsym beta 3)
	(defsym cont-bit 2)
	(defsym short-bit 1)
	(defsym meta-mask 400)
	(defsym control-mask 200)

em:get-mail
	(skipl 0 mailinp)		;-1 means mail in and not read
	(mail 2 mailbox)		;SRCV
	(jfcl)
	(setzm 0 mailinp)
	(setzm 0 tyi-inited)
	(movei b 'nil)
	(movem b (special sail-mail-interrupt))
 	(hlrz tt mailbox)		;get EPR half
 	(caie tt epr)			;is it EPR (in sixbit)?
 	(jrst 0 wrongj)
	(hrrz tt mailbox)		;get the jobnum
	(skipg 0 jobnum)
	(jrst 0 gm1)
	(came tt jobnum)		;correct one?
	(jrst 0 wrongj)
   	(movem tt jobread)
gm1	(movem tt jobnum)
	(movem tt jobn2)
	(jsp t fxcons)			;number cons
	(movem a (special -em:jobnum-)) ;save it
   	(move tt (+ mailbox 1))		;type bits
	(jrst 0 em:mail-type)

true	(movei a 't)
	(popj p)
false	(movei a 'nil)
	(popj p)

(entry em:get-jobnum subr)
(args em:get-jobnum (nil . 0))
	(move tt (special sail-mail-interrupt))
	(jsp t fxcons)			;find that entry!
	(movem a (special -em:jobnum-))
	(popj p)

(entry em:set-jobnum subr)
(args em:set-jobnum (nil . 1))
	(move tt 0 a)
	(movem a (special -em:jobnum-))
	(movem tt jobnum)
	(popj p)
wrongj 	(movei a 'wrong-jobnum)
	(popj p)
(entry em:mail-type subr)
(args em:mail-type (nil . 0))

em:mail-type
	(setzm 0 explicit-eof)	;0 means nil
	(setzm 0 forcedp)
	(move tt (+ mailbox 1));type bits
	(movei a 'nil)		;short flag
	(tlne tt short-bit)
	(movei a 't)
	(movem a (special -em:shortp-))
	(movei a 'nil)
	(tlne tt cont-bit)
	(movei a 't)
	(movem a (special -em:contp-))
	(hrrzs 0 tt)		;grumble, test for range
	(skipge 0 tt)		;too low?
	 (jrst 0 unknown)	;yup, unknown
	(caile tt high-command) ;too high
	 (jrst 0 unknown)
	(xct 0 type-disp tt)	;dispatch
unknown (movei a 'unknown)
	(popj p)
type-disp
	(jrst 0 no-op)
	(jrst 0 initiate)
	(jrst 0 ok)
	(jrst 0 sexps)
	(jrst 0 explicit-eof)
	(jrst 0 e-command)
	(jrst 0 interrupt)
	(jrst 0 kill)
	(jrst 0 readonlyvars)

e-command 
	(movei a 'ecommand)
	(popj p)
no-op
	(movei a 'no-op)
	(popj p)
sexps	
	(setzm 0 eofp)		;within eof
	(skipe 0 inbytes)
	(jrst 0 snot-finished)
sresume	(move a (+ mailbox 2))	;get number of bytes
	(move tt (+ mailbox 1));type bits
	(setzm 0 tyi-inited)	;tyi not inited
	(hlrem a inbytes)	;store it
	(hlre b a)		;-number of bytes
	(idivi b 4)		;-number of words
	(jumpe c ztesch)
	(subi b 1)		;one more, bunkie
ztesch	
	(movem b inwords)
	(setom 0 mailprocessed)
	(tlne tt short-bit)	;short?
	(jrst 0 tshort)
	(pushj p transfer-buffer)
	(movei a 'sexps)
	(popj p)
tshort	(pushj p transfer-short)
	(movei a 'sexps)
	(popj p)
initiate(movei a 'initiate)
	(setom 0 mailprocessed)
	(popj p)
readonlyvars
	(movei a 'readonlyvars)
	(setom 0 mailprocessed)
	(popj p)
interrupt
	(movei a 'interrupt)
	(setzm 0 mailprocessed)
	(popj p)
explicit-eof
	(setom 0 explicit-eof)
	(movei a 'eof)
	(popj p)
ok
	(movei a 'ok)
	(setzm 0 mailprocessed)
	(popj p)

kill	(pushj p send-ok)
	(calli 1 12)	;kill self

snot-finished
	(setzm 0 tyi-inited)
	(movei a sresume)
	(movem a resume-pc)
	(movei a 'sexps)
	(popj p)

(entry em:wait-mail subr)
(args em:wait-mail (nil . 0))

em:wait-mail
	(skipe 0 tyop)
 	(pushj p force2)
 	(722←33 0 mailint)	;imskcl
	(mail 1 mailbox)	;WRCV
 	(721←33 0 mailint)	;imskst
	(setom 0 mailprocessed)	;mail now in
	(setom 0 mailinp)	;got mail
      	(movei a 't)
	(popj p)

(entry em:mask-off subr)
(args em:mask-off (nil . 0))
	(722←33 0 mailint)	;imskcl
	(movei a 't)
	(popj p)

(entry em:mask-on subr)
(args em:mask-on (nil . 0))
	(721←33 0 mailint)	;imskst
	(movei a 't)
	(popj p)
(entry em:mail-sfa subr)
(args em:mail-sfa (nil . 3))
	(movei a 0 b)	;operation type ignore the object
	(caie a 'which-operations)
	(jrst 0 t1)
	(movei a '(tyi tyo terpri force-output untyi charpos linel
		       send-lines report-send-lines))
	(popj p)
t1	(cain a 'tyi)		;tyi?
	(jrst 0 em:mail-tyi)
	(cain a 'tyo)		;tyo?
	(jrst 0 em:mail-tyo)
	(cain a 'terpri)
	(jrst 0 em:terpri)
	(cain a 'force-output)	;force output?
	(jrst 0 em:mail-force-output)
	(cain a 'untyi)		;untyi?
	(jrst 0 em:mail-untyi)
	(cain a 'charpos)
	(jrst 0 em:mail-charpos)
	(cain a 'linel)
	(jrst 0 em:mail-linel)
	(cain a 'send-lines)
	(jrst 0 isend-lines)
	(cain a 'report-send-lines)
	(jrst 0 report-send-lines)
	(movei a 'nil)
	(popj p)

(entry em:mail-charpos subr)
(args em:mail-charpos (nil . 0))
em:mail-charpos
	(move tt charpos)
	(jrst 0 fix1)

em:mail-linel
	(movei t g1) 
	(push p t) 
	(push p (% 0 0 't)) 
	(movni t 1) 
	(jcall 16 'linel) 
g1	(popj p) 

isend-lines
	(movem c send-lines)
	(move c @ c)
	(movem c skipp)
	(movem c vsend-lines)
	(movei a 't)
	(popj p)

report-send-lines
	(move a send-lines)
	(popj p)

(entry em:init-send-lines subr)
(args em:init-send-lines (nil . 0))
	(movei tt 0)
	(movem tt vsend-lines)
	(movem tt skipp)
	(movei a 'NIL)
	(movem a send-lines)
	(popj p)

em:terpri
	(setzm 0 firstyo)
	(setzm 0 forcedp)
	(setom 0 tyop)
	(movei a cr)
	(pushj p tyo1)
	(movei a lf)
	(jrst 0 tyo1)
;;; TYI

(entry em:mail-tyi subr)
em:mail-tyi
	(skipe 0 explicit-eof)
	(jrst 0 eeof)
	(movem c eofchar)
	(skipe 0 untyif)
	(jrst 0 untyi2)
	(skipn 0 tyi-inited)	;not inited?
	(pushj p real-mail-refresh)
ityi	(skipe 0 inbytes)	;and nothing left?
	 (jrst 0 tyi1)
	(skipe 0 (special -em:contp-))	;a continuation?
	 (jrst 0 tyi2)
  	(skipe 0 (special -em:filemode-))	;in special file mode?
	 (jrst 0 reof)
tyi2	(pushj p mail-refresh)
tyi1	(aosle 0 inbytes)
	(pushj p mail-refresh)
inmailok
	(ildb tt inpoint)	;get byte
	(skipl 0 tt)		;- means end of file
	(jrst 0 fix1)		;what a bum!
	(pushj p mail-refresh)
	(jrst 0 tyi1)

em:mail-untyi
	(aos 0 untyif)
	(move b untyipdl)
	(push b c)
	(movem b untyipdl)
	(popj p)

untyi2	(move b untyipdl)
	(sosl 0 untyif)
	(pop b a)
	(movem b untyipdl)
	(popj p)
	
eeof	(setzm 0 explicit-eof)

reof
	(setom 0 eofp)
	(move a eofchar)
	(sub p (% 0 0 1 1))
	(popj p)
;;; TYO

(entry em:mail-tyo subr)
em:mail-tyo
	(setzm 0 forcedp)
	(setom 0 tyop)
	(move a @ c)
	(cain a cr)
	(jrst 0 pondercr)
	(cain a lf)
	(jrst 0 ponderlf)
tyo1	(aos 0 charpos)
	(idpb a outpoint)	;put it there
	(sosg 0 outbytes)	;ready to send?
	(pushj p cmail-sendit)
	(caie a lf)
	(jrst 0 true)
forceit
	(skipn 0 send-lines)	;if NIL then just return
	(jrst 0 force1)
	(movei tt 't)
	(camn tt send-lines)
	(jrst 0 true)
	(sosle 0 skipp)		;ready to do it?
	(jrst 0 true)
force1	(pushj p fmail-sendit)
	(movei a 't)
	(popj p)

;;; special entry for Refresh case only

force2	(skipn 0 send-lines)	;if NIL then just return
	(jrst 0 force1)
	(popj p)

pondercr
	(skipn 0 firstyo)
	(jrst 0 tyo1)
	(jrst 0 true)
ponderlf
	(skipn 0 firstyo)
	(jrst 0 tyo1)
	(setzm 0 firstyo)
	(jrst 0 true)
;;; FORCE OUTPUT

fmail-sendit
	(setom 0 forcedp)
	(setz b)
	(jrst 0 mail-sendit)
cmail-sendit
	(movei tt cont-bit)
	(jrst 0 mail-sendit)

em:mail-force-output
(entry em:mail-force-output subr)
	(skipe 0 forcedp)
	(jrst 0 true)
	(setz b)		;continuation
mail-sendit
	(setom 0 firstyo)
	(setzm 0 charpos)
	(setzm 0 tyop)
	(move a vsend-lines)
	(movem a skipp)

;	(movei a 40)		;space
;	(aos 0 charpos)
;	(idpb a outpoint)
;	(sos 0 outbytes)	;extra byte

	(movei a outmail)	;address of buffer
	(movem a (+ mailbox 2))
	(move a outbytes)	
	(movei a (+ noutbytes 1))
	(sub a outbytes)	
	(movei t 1)		;1 in t means long
	(caile a 145.)		;short enough
	(jrst 0 send-message)	;nope
	(setz t)		;0 in T means short
	(hrlzi tt outmail)
	(hrri  tt (+ mailbox 3))
	(blt tt (+ mailbox 32.))	;move to the right place
	(iori b short-bit)
send-message
	(hrl tt b)		;swap
	(hrri tt sexp-type)
	(skipe 0 (special -em:e-commands-))
	(hrri tt ecommand-type)
	(movem tt (+ mailbox 1))
	(movns 0 a)
	(hrlzm a (+ mailbox 2))
	(movei a outmail)
	(hrrm a (+ mailbox 2))
	(move a thisjob)
 	(hrli a epr)		;epr validation
	(movem a mailbox)
	(pushj p wait-for-clear)
	(mail 0 jobnum)		;mail it
	(jrst 0 false)
	(hrlzi a outmail)
	(hrri a (+ outmail 1))
	(setzm 0 outmail)
	(blt a (+ outmail (- rdblk 1)))	;zero it
	(hrlzi a mailbox)
	(hrri a (+ mailbox 1))
	(setzm 0 mailbox)
	(blt a (+ mailbox 32.))	;zero it
	(move a outpointtem)	;setup output byte count
	(movem a outpoint)
	(movei a (+ noutbytes 1))
	(movem a outbytes)
	(jumpe t true)		;don't hang around
	(pushj p wait-ok)	;wait for acknowledgment
	(pushj p em:mail-type)
	(came a 'ok)
	(jrst 0 false)
	(jrst 0 true)

;;; This routine gets fresh mail to initialize the reader
mail-refresh
real-mail-refresh
	(skipn 0 mailprocessed)	;processed?
	(jrst 0 mr1)		;get the next batch
mr3	(pushj p em:wait-mail)	;wait for response
	(jrst 0 em:get-mail)	;get the mail

mr1	(skipn 0 resume-pc)	;ready for crock?
	(jrst 0 mr3)		;nope
    	(pushj p @ resume-pc)	;get the rest
	(popj p)		;continue
;;; This routine does a jobread into the right spot.

transfer-buffer
	(move a inpointtem)	;byte pointer template
	(movem a inpoint)
	(setom 0 tyi-inited)	;ready to read
	(movei tt jobread)
	(pushj p zinmail)
	(move a (+ mailbox 2))
	(hrl a inwords)
	(movem a (+ jobread 1))
	(calli tt 400050)	;jobrd
	(jrst 0 false)
	(jrst 0 send-ok)
	(popj p)		;good return

zinmail
	(hrlzi a inmail)
	(hrri a (+ inmail 1))
	(setzm 0 inmail)
	(blt a (+ inmail (- rdblk 1)))
	(popj p)

(entry em:clear-input subr)
(args em:clear-input (nil . 0))
	(setzm 0 tyop)
	(setzm 0 firstyo)
	(setzm 0 forcedp)
	(setzm 0 untyif)
	(setzm 0 inbytes)
	(move a temuntyipdl)
	(movem a untyipdl)
	(setom 0 explicit-eof)
	(setom 0 eofp)
	(setzm 0 mailinp)
	(setom 0 mailprocessed)
	(setzm 0 tyi-inited)
	(pushj p zinmail)
	(movei a 't)
	(popj p)
wait-ok  
 	(722←33 0 mailint)	; mskcl
	(mail 1 mailbox)	;WRCV
 	(721←33 0 mailint)	;imskst
	(move tt (+ mailbox 2))
	(setzm 0 mailinp)
	(hrrzs tt)		;flush short?
	(caie tt ok-type)
	(jrst 0 true)
	(jrst 0 false)
(entry em:send-simple-message subr)
(args em:send-simple-message (nil . 2))

	(cain a 'initiate)
	(jrst 0 initiate-message)
	(cain a 'ok)
	(jrst 0 ok-message)
	(cain a 'hold-it)
	(jrst 0 hold-it-message)
	(cain a 'eof)
	(jrst 0 eof-message)
	(movei a 'Invalid-message)
	(popj p)

eof-message
	(movei a explicit-eof-type)
	(jrst 0 send-simple-message)
initiate-message
	(movei a initiate-type)
	(jrst 0 send-simple-message)
ok-message
	(movei a ok-type)
	(jrst 0 send-simple-message)
hold-it-message
	(movei a 102)
	(movem a (+ mailb2 2))
	(movei a interrupt-type)

send-simple-message
	(movem a (+ mailb2 1))
	(move b 0 b)
	(movem b jobn2)
	(movem b jobnum)
	(move b thisjob)
 	(hrl b epr)
	(movem b mailb2)
	(movem b mailbox)
	(pushj p wait-for-clear)
     	(mail 0 jobn2)
	(jrst 0 false)
	(jrst 0 true)

wait-for-clear
	(mail 4 jobnum)
	(popj p)
	(setz tt)
	(calli tt 31)
	(jrst 0 wait-for-clear)

(entry em:send-control-char subr)
(args em:send-control-char (nil . 2))

send-control-char
	(movei t -1)		;count
	(move tt outchartem)
	(move a 0 a)		;get character
	(trne a 600)	 	;control and meta?
	(jrst 0 cm1)
	(trze a 200)		;control bit
	(pushj p c1)		;push control
	(trze a 400)		;meta bit
	(pushj p m1)		;push meta
cm2	(aos 0 charpos)
	(idpb a tt)
	(movei a ecommand-type)
	(hrli a short-bit)	;short control chars
	(movem a (+ mailb2 1))
	(hrlzm t (+ mailb2 2))
	(movei a outmail)
	(hrrm a (+ mailb2 2))

	(move b 0 b)
	(movem b jobn2)
	(movem b jobnum)
	(move b thisjob)
 	(hrl b epr)
	(movem b mailb2)
	(movem b mailbox)
	(pushj p wait-for-clear)
     	(mail 0 jobn2)
	(jrst 0 false)
	(jrst 0 true)

c1	(movei r 2)		;alpha
	(aos 0 charpos)
	(idpb r tt)		;send it
	(sos 0 t)		;decrement
	(popj p)

m1	(movei r 3)		;beta
	(aos 0 charpos)
	(idpb r tt)		;send it
	(sos 0 t)		;decrement
	(popj p)

cm1	(movei r #o26)
	(aos 0 charpos)
	(idpb r tt)
	(sos 0 t)
	(trz r 600)
	(jrst 0 cm2)
(entry em:init subr)
(args em:init (nil . 0))

	(setzm 0 mailinp)
	(setom 0 jobnum)
	(calli tt 30)
	(movem tt thisjob)
	(jrst 0 fix1)

transfer-short

	(move a inpointtem)	;byte pointer template
	(movem a inpoint)
	(pushj p zinmail)
	(hrlzi a (+ mailbox 3))	;move from here
	(hrri a inmail)		;to here
	(blt a (+ inmail 30.))	;transfer 30
	(setom 0 tyi-inited)	;ready to read
	(popj p)

send-ok
	(movei a ok-type)
	(movem a (+ mailb2 1))
	(move b thisjob)
 	(hrli b epr)
	(movem b mailb2)
	(pushj p wait-for-clear)
     	(mail 0 jobn2)
	(jrst 0 false)
	(jrst 0 true)
(entry em:eval-protect subr)
(args em:eval-protect (nil . 0))
(movei a mailbox)
(movem a (special sail-mail-address))
(movei a 't)
(popj p)

(entry em:eval-unprotect subr)
(args em:eval-unprotect (nil . 0))
(movei a 'nil)
(movem a (special sail-mail-address))
(popj p)
;;; Routines for obtaining the values of readonly variables

(entry em:readonly-values subr)
(args em:readonly-values  (nil . 1))

;;; Takes list of variables and returns an alist of variable-value pairs
sixmak 	(movei b '6)				;direct lift from faslap
	(call 2 'pnget)
	(hlrz a 0 a)
	(move tt 0 a)
	(popj p)
just	(tlne tt 77)
	(popj p)
	(lsh tt -6)
	(jrst 0 just)
;;; Storage for Mail routines

firstyo (0)
send-lines (0)
vsend-lines (0)
skipp (0)
tyop (0)
forcedp (0)		;output already forced
inwords (0)		;number of words to input via jobread
explicit-eof (-1)	;nil
eofp (-1)		;-1 means mail in and not read
mailinp (0)		;-1 means mail in and not read
mailint (4000000000)
jobnum	(0)
	(0 0 mailbox)

;(entry mailbox subr)

mailbox	(block 32.)	;mail
jobn2 (0)
	(0 0 mailb2)

;(entry mailb2 subr)

mailb2(block 32.)	;short mail

;(entry inmail subr)

inmail	(block blksize)	;text

;(entry outmail subr)

outmail	(block blksize)	;text
stack (block 20)
untyipdl (777760←22 0 stack)
temuntyipdl (777760←22 0 stack)
untyif (0)

;(entry inpoint subr)
;inpoint (700←22 0 (- inmail 1))
;inpointtem (700←22 0 (- inmail 1))

inpoint (1100←22 0 (- inmail 1))
inpointtem (1100←22 0 (- inmail 1))
inbytes (0)
outpoint (700←22 0 (- outmail 1))
outpointtem (700←22 0 (- outmail 1))
outchartem (700←22 0 (+ mailb2 2))
outbytes (0 0 (% 0 0 (+ noutbytes 1)))
mailprocessed (-1)	;0 means not processed
charpos (0)
tyi-inited (0)		;ready to read. 0 = nil, -1 = t
resume-pc  (0)		;where to get more chars
eofchar (0)		;eof char
thisjob (0)
jobread	(0)
	(0)
	(0 0 inmail)
()

(or (and (boundp 'em:no-init) em:no-init)
    (progn (em:initialize) 
 	   (em:eval-protect)
	   (sstatus ttyint 232. '+internal-↑B-break)
	   (princ '|MacLisp Ready|)))